package org.ruoyi.interview.service.impl;

import lombok.extern.slf4j.Slf4j;
import org.ruoyi.interview.config.Ultra;
import org.ruoyi.interview.config.XunfeiSparkConfig;
import org.ruoyi.interview.service.IInterviewAIService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import org.springframework.beans.factory.InitializingBean;
import java.util.HashMap;
import java.util.Map;
import java.util.List;
import java.util.ArrayList;
import java.util.concurrent.ConcurrentHashMap;

/**
 * AI模型管理器，支持多种AI模型的统一调用
 */
@Slf4j
@Component
public class AIModelManager implements InitializingBean {

    @Autowired
    private XunfeiSparkConfig xunfeiSparkConfig;

    // ModelScope服务
    private IInterviewAIService modelScopeService;

    // 讯飞星火服务
    private Ultra ultra;

    // 存储用户会话历史
    private Map<Long, List<Ultra.RoleContent>> userHistories = new ConcurrentHashMap<>();

    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化讯飞星火客户端
        ultra = new Ultra();
        ultra.setApiKey(xunfeiSparkConfig.getApiKey());
        ultra.setApiSecret(xunfeiSparkConfig.getApiSecret());
        ultra.setAppId(xunfeiSparkConfig.getAppId());
    }

    /**
     * 设置ModelScope服务
     * @param service ModelScope服务实例
     */
    public void setModelScopeService(IInterviewAIService service) {
        this.modelScopeService = service;
    }

    /**
     * 调用指定AI模型回答问题
     *
     * @param model   AI模型名称 ("modelscope" 或 "xunfei")
     * @param question 用户问题
     * @param userId   用户ID（用于维护对话历史）
     * @return 模型回答
     * @throws Exception 调用异常
     */
    public String askModel(String model, String question, Long userId) throws Exception {
        switch (model.toLowerCase()) {
            case "modelscope":
                if (modelScopeService != null) {
                    return modelScopeService.askModel(question);
                } else {
                    throw new Exception("ModelScope服务未配置");
                }
            case "xunfei":
                try {
                    log.info("调用讯飞星火API，用户ID：{}，问题：{}", userId, question);

                    // 获取用户历史对话记录
//                    List<Ultra.RoleContent> history = userHistories.computeIfAbsent(userId, k -> new ArrayList<>());

                    // 调用API
                    String response = ultra.chat(question, new ArrayList<>());

                    log.info("讯飞星火API返回结果：{}", response);

                    return response;
                } catch (Exception e) {
                    log.error("调用讯飞星火API失败，用户ID：{}，问题：{}", userId, question, e);
                    throw new Exception("调用讯飞星火API失败: " + e.getMessage(), e);
                }
            default:
                throw new Exception("不支持的AI模型: " + model);
        }
    }

    /**
     * 清除用户历史对话记录
     *
     * @param userId 用户ID
     */
    public void clearHistory(Long userId) {
        userHistories.remove(userId);
    }

    /**
     * 获取支持的AI模型列表
     * @return 支持的AI模型列表
     */
    public List<String> getSupportedModels() {
        List<String> models = new ArrayList<>();
        models.add("modelscope");
        models.add("xunfei");
        return models;
    }
}
